home *** CD-ROM | disk | FTP | other *** search
/ PC World Komputer 2010 April / PCWorld0410.iso / hity wydania / Ubuntu 9.10 PL / karmelkowy-koliberek-9.10-netbook-remix-PL.iso / casper / filesystem.squashfs / usr / share / pyshared / DistUpgrade / DistUpgradeViewGtk.py < prev    next >
Encoding:
Python Source  |  2009-11-02  |  27.2 KB  |  693 lines
  1. # DistUpgradeViewGtk.py 
  2. #  
  3. #  Copyright (c) 2004-2006 Canonical
  4. #  
  5. #  Author: Michael Vogt <michael.vogt@ubuntu.com>
  6. # 
  7. #  This program is free software; you can redistribute it and/or 
  8. #  modify it under the terms of the GNU General Public License as 
  9. #  published by the Free Software Foundation; either version 2 of the
  10. #  License, or (at your option) any later version.
  11. # 
  12. #  This program is distributed in the hope that it will be useful,
  13. #  but WITHOUT ANY WARRANTY; without even the implied warranty of
  14. #  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15. #  GNU General Public License for more details.
  16. # 
  17. #  You should have received a copy of the GNU General Public License
  18. #  along with this program; if not, write to the Free Software
  19. #  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
  20. #  USA
  21.  
  22. import pygtk
  23. pygtk.require('2.0')
  24. import gtk
  25. import gtk.gdk
  26. import vte
  27. import gobject
  28. import pango
  29. import sys
  30. import locale
  31. import logging
  32. import time
  33. import subprocess
  34.  
  35. import apt
  36. import apt_pkg
  37. import os
  38.  
  39. from DistUpgradeApport import *
  40.  
  41. from DistUpgradeView import DistUpgradeView, FuzzyTimeToStr, InstallProgress, FetchProgress
  42. from SimpleGtkbuilderApp import SimpleGtkbuilderApp
  43.  
  44. import gettext
  45. from DistUpgradeGettext import gettext as _
  46.  
  47. def utf8(str):
  48.   return unicode(str, 'latin1').encode('utf-8')
  49.  
  50. class GtkCdromProgressAdapter(apt.progress.CdromProgress):
  51.     """ Report the cdrom add progress
  52.         Subclass this class to implement cdrom add progress reporting
  53.     """
  54.     def __init__(self, parent):
  55.         self.status = parent.label_status
  56.         self.progress = parent.progressbar_cache
  57.         self.parent = parent
  58.     def update(self, text, step):
  59.         """ update is called regularly so that the gui can be redrawn """
  60.         if text:
  61.           self.status.set_text(text)
  62.         self.progress.set_fraction(step/float(self.totalSteps))
  63.         while gtk.events_pending():
  64.           gtk.main_iteration()
  65.     def askCdromName(self):
  66.         return (False, "")
  67.     def changeCdrom(self):
  68.         return False
  69.  
  70. class GtkOpProgress(apt.progress.OpProgress):
  71.   def __init__(self, progressbar):
  72.       self.progressbar = progressbar
  73.       #self.progressbar.set_pulse_step(0.01)
  74.       #self.progressbar.pulse()
  75.  
  76.   def update(self, percent):
  77.       #if percent > 99:
  78.       #    self.progressbar.set_fraction(1)
  79.       #else:
  80.       #    self.progressbar.pulse()
  81.       self.progressbar.set_fraction(percent/100.0)
  82.       while gtk.events_pending():
  83.           gtk.main_iteration()
  84.  
  85.   def done(self):
  86.       self.progressbar.set_text(" ")
  87.  
  88.  
  89. class GtkFetchProgressAdapter(FetchProgress):
  90.     # FIXME: we really should have some sort of "we are at step"
  91.     # xy in the gui
  92.     # FIXME2: we need to thing about mediaCheck here too
  93.     def __init__(self, parent):
  94.         FetchProgress.__init__(self)
  95.         # if this is set to false the download will cancel
  96.         self.status = parent.label_status
  97.         self.progress = parent.progressbar_cache
  98.         self.parent = parent
  99.         self.canceled = False
  100.         self.button_cancel = parent.button_fetch_cancel
  101.         self.button_cancel.connect('clicked', self.cancelClicked)
  102.     def cancelClicked(self, widget):
  103.         logging.debug("cancelClicked")
  104.         self.canceled = True
  105.     def mediaChange(self, medium, drive):
  106.         #print "mediaChange %s %s" % (medium, drive)
  107.         msg = _("Please insert '%s' into the drive '%s'") % (medium,drive)
  108.         dialog = gtk.MessageDialog(parent=self.parent.window_main,
  109.                                    flags=gtk.DIALOG_MODAL,
  110.                                    type=gtk.MESSAGE_QUESTION,
  111.                                    buttons=gtk.BUTTONS_OK_CANCEL)
  112.         dialog.set_markup(msg)
  113.         res = dialog.run()
  114.         dialog.destroy()
  115.         if res == gtk.RESPONSE_OK:
  116.             return True
  117.         return False
  118.     def start(self):
  119.         #logging.debug("start")
  120.         FetchProgress.start(self)
  121.         self.progress.set_fraction(0)
  122.         self.status.show()
  123.         self.button_cancel.show()
  124.     def stop(self):
  125.         #logging.debug("stop")
  126.         self.progress.set_text(" ")
  127.         self.status.set_text(_("Fetching is complete"))
  128.         self.button_cancel.hide()
  129.     def pulse(self):
  130.         # FIXME: move the status_str and progress_str into python-apt
  131.         # (python-apt need i18n first for this)
  132.         FetchProgress.pulse(self)
  133.         self.progress.set_fraction(self.percent/100.0)
  134.         currentItem = self.currentItems + 1
  135.         if currentItem > self.totalItems:
  136.             currentItem = self.totalItems
  137.  
  138.         if self.currentCPS > 0:
  139.             self.status.set_text(_("Fetching file %li of %li at %sB/s") % (currentItem, self.totalItems, apt_pkg.SizeToStr(self.currentCPS)))
  140.             self.progress.set_text(_("About %s remaining") % FuzzyTimeToStr(self.eta))
  141.         else:
  142.             self.status.set_text(_("Fetching file %li of %li") % (currentItem, self.totalItems))
  143.             self.progress.set_text("  ")
  144.  
  145.         while gtk.events_pending():
  146.             gtk.main_iteration()
  147.         return (not self.canceled)
  148.  
  149. class GtkInstallProgressAdapter(InstallProgress):
  150.     # timeout with no status change when the terminal is expanded
  151.     # automatically
  152.     TIMEOUT_TERMINAL_ACTIVITY = 240
  153.     
  154.     def __init__(self,parent):
  155.         InstallProgress.__init__(self)
  156.         self._cache = None
  157.         self.label_status = parent.label_status
  158.         self.progress = parent.progressbar_cache
  159.         self.expander = parent.expander_terminal
  160.         self.term = parent._term
  161.         self.parent = parent
  162.         # setup the child waiting
  163.         reaper = vte.reaper_get()
  164.         reaper.connect("child-exited", self.child_exited)
  165.         # some options for dpkg to make it die less easily
  166.         apt_pkg.Config.Set("DPkg::StopOnError","False")
  167.  
  168.     def startUpdate(self):
  169.         InstallProgress.startUpdate(self)
  170.         self.finished = False
  171.         # FIXME: add support for the timeout
  172.         # of the terminal (to display something useful then)
  173.         # -> longer term, move this code into python-apt 
  174.         self.label_status.set_text(_("Applying changes"))
  175.         self.progress.set_fraction(0.0)
  176.         self.progress.set_text(" ")
  177.         self.expander.set_sensitive(True)
  178.         self.term.show()
  179.         # if no libgnome2-perl is installed show the terminal
  180.         frontend= os.environ.get("DEBIAN_FRONTEND") or "gnome"
  181.         if frontend == "gnome" and self._cache:
  182.           if (not self._cache.has_key("libgnome2-perl") or 
  183.               not self._cache["libgnome2-perl"].isInstalled):
  184.             frontend = "dialog"
  185.             self.expander.set_expanded(True)
  186.         self.env = ["VTE_PTY_KEEP_FD=%s"% self.writefd,
  187.                     "APT_LISTCHANGES_FRONTEND=none"]
  188.         if not os.environ.has_key("DEBIAN_FRONTEND"):
  189.           self.env.append("DEBIAN_FRONTEND=%s" % frontend)
  190.         # do a bit of time-keeping
  191.         self.start_time = 0.0
  192.         self.time_ui = 0.0
  193.         self.last_activity = 0.0
  194.         
  195.     def error(self, pkg, errormsg):
  196.         InstallProgress.error(self, pkg, errormsg)
  197.         logging.error("got an error from dpkg for pkg: '%s': '%s'" % (pkg, errormsg))
  198.     # we do not report followup errors from earlier failures
  199.         if gettext.dgettext('dpkg', "dependency problems - leaving unconfigured") in errormsg:
  200.       return False
  201.  
  202.         #self.expander_terminal.set_expanded(True)
  203.         self.parent.dialog_error.set_transient_for(self.parent.window_main)
  204.         summary = _("Could not install '%s'") % pkg
  205.         msg = _("The upgrade will continue but the '%s' package may not "
  206.                 "be in a working state. Please consider submitting a "
  207.                 "bug report about it.") % pkg
  208.         markup="<big><b>%s</b></big>\n\n%s" % (summary, msg)
  209.         self.parent.dialog_error.realize()
  210.         self.parent.dialog_error.window.set_functions(gtk.gdk.FUNC_MOVE)
  211.         self.parent.label_error.set_markup(markup)
  212.         self.parent.textview_error.get_buffer().set_text(utf8(errormsg))
  213.         self.parent.scroll_error.show()
  214.         self.parent.dialog_error.run()
  215.         self.parent.dialog_error.hide()
  216.  
  217.     def conffile(self, current, new):
  218.         logging.debug("got a conffile-prompt from dpkg for file: '%s'" % current)
  219.         start = time.time()
  220.         #self.expander.set_expanded(True)
  221.         prim = _("Replace the customized configuration file\n'%s'?") % current
  222.         sec = _("You will lose any changes you have made to this "
  223.                 "configuration file if you choose to replace it with "
  224.                 "a newer version.")
  225.         markup = "<span weight=\"bold\" size=\"larger\">%s </span> \n\n%s" % (prim, sec)
  226.         self.parent.label_conffile.set_markup(markup)
  227.         self.parent.dialog_conffile.set_transient_for(self.parent.window_main)
  228.  
  229.         # now get the diff
  230.         if os.path.exists("/usr/bin/diff"):
  231.           cmd = ["/usr/bin/diff", "-u", current, new]
  232.           diff = utf8(subprocess.Popen(cmd, stdout=subprocess.PIPE).communicate()[0])
  233.           self.parent.textview_conffile.get_buffer().set_text(diff)
  234.         else:
  235.           self.parent.textview_conffile.get_buffer().set_text(_("The 'diff' command was not found"))
  236.         res = self.parent.dialog_conffile.run()
  237.         self.parent.dialog_conffile.hide()
  238.         self.time_ui += time.time() - start
  239.         # if replace, send this to the terminal
  240.         if res == gtk.RESPONSE_YES:
  241.           self.term.feed_child("y\n")
  242.         else:
  243.           self.term.feed_child("n\n")
  244.         
  245.     def fork(self):
  246.         pid = self.term.forkpty(envv=self.env)
  247.         if pid == 0:
  248.           # WORKAROUND for broken feisty vte where envv does not work)
  249.           for env in self.env:
  250.             (key, value) = env.split("=")
  251.             os.environ[key] = value
  252.           # HACK to work around bug in python/vte and unregister the logging
  253.           #      atexit func in the child
  254.           sys.exitfunc = lambda: True
  255.         return pid
  256.  
  257.     def statusChange(self, pkg, percent, status):
  258.         # start the timer when the first package changes its status
  259.         if self.start_time == 0.0:
  260.           #print "setting start time to %s" % self.start_time
  261.           self.start_time = time.time()
  262.         self.progress.set_fraction(float(percent)/100.0)
  263.         self.label_status.set_text(status.strip())
  264.         # start showing when we gathered some data
  265.         if percent > 1.0:
  266.           self.last_activity = time.time()
  267.           self.activity_timeout_reported = False
  268.           delta = self.last_activity - self.start_time
  269.           # time wasted in conffile questions (or other ui activity)
  270.           delta -= self.time_ui
  271.           time_per_percent = (float(delta)/percent)
  272.           eta = (100.0 - percent) * time_per_percent
  273.           # only show if we have some sensible data (60sec < eta < 2days)
  274.           if eta > 61.0 and eta < (60*60*24*2):
  275.             self.progress.set_text(_("About %s remaining") % FuzzyTimeToStr(eta))
  276.           else:
  277.             self.progress.set_text(" ")
  278.  
  279.     def child_exited(self, term, pid, status):
  280.         # we need to capture the full status here (not only the WEXITSTATUS)
  281.         self.apt_status = status
  282.         self.finished = True
  283.  
  284.     def waitChild(self):
  285.         while not self.finished:
  286.             self.updateInterface()
  287.         return self.apt_status
  288.  
  289.     def finishUpdate(self):
  290.         self.label_status.set_text("")
  291.     
  292.     def updateInterface(self):
  293.         try:
  294.           InstallProgress.updateInterface(self)
  295.         except ValueError, e:
  296.           logging.error("got ValueError from InstallProgress.updateInterface. Line was '%s' (%s)" % (self.read, e))
  297.           # reset self.read so that it can continue reading and does not loop
  298.       self.read = ""
  299.         # check if we haven't started yet with packages, pulse then
  300.         if self.start_time == 0.0:
  301.           self.progress.pulse()
  302.           time.sleep(0.2)
  303.         # check about terminal activity
  304.         if self.last_activity > 0 and \
  305.            (self.last_activity + self.TIMEOUT_TERMINAL_ACTIVITY) < time.time():
  306.           if not self.activity_timeout_reported:
  307.             logging.warning("no activity on terminal for %s seconds (%s)" % (self.TIMEOUT_TERMINAL_ACTIVITY, self.label_status.get_text()))
  308.             self.activity_timeout_reported = True
  309.           self.parent.expander_terminal.set_expanded(True)
  310.         while gtk.events_pending():
  311.             gtk.main_iteration()
  312.     time.sleep(0.005)
  313.  
  314. class DistUpgradeVteTerminal(object):
  315.   def __init__(self, parent, term):
  316.     self.term = term
  317.     self.parent = parent
  318.   def call(self, cmd, hidden=False):
  319.     def wait_for_child(widget):
  320.       #print "wait for child finished"
  321.       self.finished=True
  322.     self.term.show()
  323.     self.term.connect("child-exited", wait_for_child)
  324.     self.parent.expander_terminal.set_sensitive(True)
  325.     if hidden==False:
  326.       self.parent.expander_terminal.set_expanded(True)
  327.     self.finished = False
  328.     pid = self.term.fork_command(command=cmd[0],argv=cmd)
  329.     if pid < 0:
  330.       # error
  331.       return 
  332.     while not self.finished:
  333.       while gtk.events_pending():
  334.         gtk.main_iteration()
  335.       time.sleep(0.1)
  336.     del self.finished
  337.  
  338. class DistUpgradeViewGtk(DistUpgradeView,SimpleGtkbuilderApp):
  339.     " gtk frontend of the distUpgrade tool "
  340.     def __init__(self, datadir=None, logdir=None):
  341.         self.logdir = logdir
  342.         if not datadir:
  343.           localedir=os.path.join(os.getcwd(),"mo")
  344.           gladedir=os.getcwd()
  345.         else:
  346.           localedir="/usr/share/locale/"
  347.           gladedir=os.path.join(datadir, "glade")
  348.  
  349.     # check if we have a display etc
  350.     gtk.init_check()
  351.  
  352.         try:
  353.           locale.bindtextdomain("update-manager",localedir)
  354.           gettext.textdomain("update-manager")
  355.         except Exception, e:
  356.           logging.warning("Error setting locales (%s)" % e)
  357.         
  358.         icons = gtk.icon_theme_get_default()
  359.         try:
  360.           gtk.window_set_default_icon(icons.load_icon("update-manager", 32, 0))
  361.         except gobject.GError, e:
  362.           logging.debug("error setting default icon, ignoring (%s)" % e)
  363.           pass
  364.         SimpleGtkbuilderApp.__init__(self, 
  365.                                      gladedir+"/DistUpgrade.ui", 
  366.                                      "update-manager")
  367.         # terminal stuff
  368.         self.create_terminal()
  369.  
  370.         self.prev_step = 0 # keep a record of the latest step
  371.         # we don't use this currently
  372.         #self.window_main.set_keep_above(True)
  373.         self.icontheme = gtk.icon_theme_get_default()
  374.         # we keep a reference pngloader around so that its in memory
  375.         # -> this avoid the issue that during the dapper->edgy upgrade
  376.         #    the loaders move from /usr/lib/gtk/2.4.0/loaders to 2.10.0
  377.         self.pngloader = gtk.gdk.PixbufLoader("png")
  378.         try:
  379.           self.svgloader = gtk.gdk.PixbufLoader("svg")
  380.           self.svgloader.close()
  381.         except gobject.GError, e:
  382.           logging.debug("svg pixbuf loader failed (%s)" % e)
  383.           pass
  384.         
  385.         self.window_main.realize()
  386.         self.window_main.window.set_functions(gtk.gdk.FUNC_MOVE)
  387.         self._opCacheProgress = GtkOpProgress(self.progressbar_cache)
  388.         self._fetchProgress = GtkFetchProgressAdapter(self)
  389.         self._cdromProgress = GtkCdromProgressAdapter(self)
  390.         self._installProgress = GtkInstallProgressAdapter(self)
  391.         # details dialog
  392.         self.details_list = gtk.ListStore(gobject.TYPE_STRING)
  393.         column = gtk.TreeViewColumn("")
  394.         render = gtk.CellRendererText()
  395.         column.pack_start(render, True)
  396.         column.add_attribute(render, "markup", 0)
  397.         self.treeview_details.append_column(column)
  398.         self.treeview_details.set_model(self.details_list)
  399.  
  400.         # Use italic style in the status labels
  401.         attrlist=pango.AttrList()
  402.         #attr = pango.AttrStyle(pango.STYLE_ITALIC, 0, -1)
  403.         attr = pango.AttrScale(pango.SCALE_SMALL, 0, -1)
  404.         attrlist.insert(attr)
  405.         self.label_status.set_property("attributes", attrlist)
  406.         # reasonable fault handler
  407.         sys.excepthook = self._handleException
  408.  
  409.     def _handleException(self, type, value, tb):
  410.       # we handle the exception here, hand it to apport and run the
  411.       # apport gui manually after it because we kill u-m during the upgrade
  412.       # to prevent it from poping up for reboot notifications or FF restart
  413.       # notifications or somesuch
  414.       import traceback
  415.       lines = traceback.format_exception(type, value, tb)
  416.       logging.error("not handled expection:\n%s" % "\n".join(lines))
  417.       # we can't be sure that apport will run in the middle of a upgrade
  418.       # so we still show a error message here
  419.       apport_crash(type, value, tb)
  420.       if not run_apport():
  421.         self.error(_("A fatal error occurred"),
  422.                    _("Please report this as a bug (if you haven't already) and include the "
  423.                      "files /var/log/dist-upgrade/main.log and "
  424.                      "/var/log/dist-upgrade/apt.log "
  425.                      "in your report. The upgrade is now aborted.\n"
  426.                      "Your original sources.list was saved in "
  427.                      "/etc/apt/sources.list.distUpgrade."),
  428.                    "\n".join(lines))
  429.       sys.exit(1)
  430.  
  431.     def getTerminal(self):
  432.         return DistUpgradeVteTerminal(self, self._term)
  433.  
  434.     def _key_press_handler(self, widget, keyev):
  435.       # user pressed ctrl-c
  436.       if len(keyev.string) == 1 and ord(keyev.string) == 3:
  437.         summary = _("Ctrl-c pressed")
  438.         msg = _("This will abort the operation and may leave the system "
  439.                 "in a broken state. Are you sure you want to do that?")
  440.         res = self.askYesNoQuestion(summary, msg)
  441.         logging.warning("ctrl-c press detected, user decided to pass it "
  442.                         "on: %s", res)        
  443.         return not res
  444.       return False
  445.  
  446.     def create_terminal(self):
  447.         " helper to create a vte terminal "
  448.         self._term = vte.Terminal()
  449.         self._term.connect("key-press-event", self._key_press_handler)
  450.         self._term.set_font_from_string("monospace 10")
  451.         self._term.connect("contents-changed", self._term_content_changed)
  452.         self._terminal_lines = []
  453.         self.hbox_custom.pack_start(self._term)
  454.         self._term.realize()
  455.         self.vscrollbar_terminal = gtk.VScrollbar()
  456.         self.vscrollbar_terminal.show()
  457.         self.hbox_custom.pack_start(self.vscrollbar_terminal)
  458.         self.vscrollbar_terminal.set_adjustment(self._term.get_adjustment())
  459.         try:
  460.           self._terminal_log = open(os.path.join(self.logdir,"term.log"),"w")
  461.         except Exception, e:
  462.           # if something goes wrong (permission denied etc), use stdout
  463.           self._terminal_log = sys.stdout
  464.         return self._term
  465.  
  466.     def _term_content_changed(self, term):
  467.         " called when the *visible* part of the terminal changes "
  468.         # get the current visible text, 
  469.         current_text = self._term.get_text(lambda a,b,c,d: True)
  470.         # see what we have currently and only print stuff that wasn't
  471.         # visible last time
  472.         new_lines = []
  473.         for line in current_text.split("\n"):
  474.           new_lines.append(line)
  475.           if not line in self._terminal_lines:
  476.             self._terminal_log.write(line+"\n")
  477.             try:
  478.               self._terminal_log.flush()
  479.             except IOError, e:
  480.               logging.exception("flush()")
  481.         self._terminal_lines = new_lines
  482.     def getFetchProgress(self):
  483.         return self._fetchProgress
  484.     def getInstallProgress(self, cache):
  485.         self._installProgress._cache = cache
  486.         return self._installProgress
  487.     def getOpCacheProgress(self):
  488.         return self._opCacheProgress
  489.     def getCdromProgress(self):
  490.         return self._cdromProgress
  491.     def updateStatus(self, msg):
  492.         self.label_status.set_text("%s" % msg)
  493.     def hideStep(self, step):
  494.         image = getattr(self,"image_step%i" % step)
  495.         label = getattr(self,"label_step%i" % step)
  496.         arrow = getattr(self,"arrow_step%i" % step)
  497.         image.hide()
  498.         label.hide()
  499.     def showStep(self, step):
  500.         image = getattr(self,"image_step%i" % step)
  501.         label = getattr(self,"label_step%i" % step)
  502.         image.show()
  503.         label.show()
  504.     def abort(self):
  505.         size = gtk.ICON_SIZE_MENU
  506.         step = self.prev_step
  507.         if step > 0:
  508.             image = getattr(self,"image_step%i" % step)
  509.             arrow = getattr(self,"arrow_step%i" % step)
  510.             image.set_from_stock(gtk.STOCK_CANCEL, size)
  511.             image.show()
  512.             arrow.hide()
  513.     def setStep(self, step):
  514.         if self.icontheme.rescan_if_needed():
  515.           logging.debug("icon theme changed, re-reading")
  516.         # first update the "previous" step as completed
  517.         size = gtk.ICON_SIZE_MENU
  518.         attrlist=pango.AttrList()
  519.         if self.prev_step:
  520.             image = getattr(self,"image_step%i" % self.prev_step)
  521.             label = getattr(self,"label_step%i" % self.prev_step)
  522.             arrow = getattr(self,"arrow_step%i" % self.prev_step)
  523.             label.set_property("attributes",attrlist)
  524.             image.set_from_stock(gtk.STOCK_APPLY, size)
  525.             image.show()
  526.             arrow.hide()
  527.         self.prev_step = step
  528.         # show the an arrow for the current step and make the label bold
  529.         image = getattr(self,"image_step%i" % step)
  530.         label = getattr(self,"label_step%i" % step)
  531.         arrow = getattr(self,"arrow_step%i" % step)
  532.         # check if that step was not hidden with hideStep()
  533.         if not label.get_property("visible"):
  534.           return
  535.         arrow.show()
  536.         image.hide()
  537.         attr = pango.AttrWeight(pango.WEIGHT_BOLD, 0, -1)
  538.         attrlist.insert(attr)
  539.         label.set_property("attributes",attrlist)
  540.  
  541.     def information(self, summary, msg, extended_msg=None):
  542.       self.dialog_information.set_transient_for(self.window_main)
  543.       msg = "<big><b>%s</b></big>\n\n%s" % (summary,msg)
  544.       self.label_information.set_markup(msg)
  545.       if extended_msg != None:
  546.         buffer = self.textview_information.get_buffer()
  547.         buffer.set_text(extended_msg)
  548.         self.scroll_information.show()
  549.       else:
  550.         self.scroll_information.hide()
  551.       self.dialog_information.realize()
  552.       self.dialog_information.window.set_functions(gtk.gdk.FUNC_MOVE)
  553.       self.dialog_information.run()
  554.       self.dialog_information.hide()
  555.       while gtk.events_pending():
  556.         gtk.main_iteration()
  557.  
  558.     def error(self, summary, msg, extended_msg=None):
  559.         self.dialog_error.set_transient_for(self.window_main)
  560.         #self.expander_terminal.set_expanded(True)
  561.         msg="<big><b>%s</b></big>\n\n%s" % (summary, msg)
  562.         self.label_error.set_markup(msg)
  563.         if extended_msg != None:
  564.             buffer = self.textview_error.get_buffer()
  565.             buffer.set_text(extended_msg)
  566.             self.scroll_error.show()
  567.         else:
  568.             self.scroll_error.hide()
  569.         self.dialog_error.realize()
  570.         self.dialog_error.window.set_functions(gtk.gdk.FUNC_MOVE)
  571.         self.dialog_error.run()
  572.         self.dialog_error.hide()
  573.         return False
  574.  
  575.     def confirmChanges(self, summary, changes, downloadSize, 
  576.                        actions=None, removal_bold=True):
  577.         # FIXME: add a whitelist here for packages that we expect to be
  578.         # removed (how to calc this automatically?)
  579.         if not DistUpgradeView.confirmChanges(self, summary, changes, downloadSize):
  580.           return False
  581.         # append warning
  582.         self.confirmChangesMessage +=  "\n\n<b>%s</b>" %  \
  583.             _("To prevent data loss close all open "
  584.               "applications and documents.")
  585.  
  586.         if actions != None:
  587.             self.button_cancel_changes.set_use_stock(False)
  588.             self.button_cancel_changes.set_use_underline(True)
  589.             self.button_cancel_changes.set_label(actions[0])
  590.             self.button_confirm_changes.set_label(actions[1])
  591.  
  592.         self.label_summary.set_markup("<big><b>%s</b></big>" % summary)
  593.         self.label_changes.set_markup(self.confirmChangesMessage)
  594.         # fill in the details
  595.         self.details_list.clear()
  596.         for dg in self.toDowngrade:
  597.             self.details_list.append([_("<b>Downgrade %s</b>") % dg])
  598.         for rm in self.toRemove:
  599.             s = _("Remove %s") % rm
  600.             if removal_bold:
  601.               s = "<b>%s</b>" % s
  602.             self.details_list.append([s])
  603.         for inst in self.toInstall:
  604.             self.details_list.append([_("Install %s") % inst])
  605.         for up in self.toUpgrade:
  606.             self.details_list.append([_("Upgrade %s") % up])
  607.         self.dialog_changes.set_transient_for(self.window_main)
  608.         # work around problem that scroll_to() does not 
  609.         # work when it is not realized
  610.         self.dialog_changes.realize()
  611.         self.treeview_details.realize()
  612.         self.treeview_details.set_cursor((0,))
  613.         self.treeview_details.scroll_to_point(0,0)
  614.         self.dialog_changes.window.set_functions(gtk.gdk.FUNC_MOVE)
  615.         res = self.dialog_changes.run()
  616.         self.dialog_changes.hide()
  617.         if res == gtk.RESPONSE_YES:
  618.             return True
  619.         return False
  620.  
  621.     def askYesNoQuestion(self, summary, msg, default='No'):
  622.         msg = "<big><b>%s</b></big>\n\n%s" % (summary,msg)
  623.         dialog = gtk.MessageDialog(parent=self.window_main,
  624.                                    flags=gtk.DIALOG_MODAL,
  625.                                    type=gtk.MESSAGE_QUESTION,
  626.                                    buttons=gtk.BUTTONS_YES_NO)
  627.         if default == 'No':
  628.           dialog.set_default_response(gtk.RESPONSE_NO)
  629.         else:
  630.           dialog.set_default_response(gtk.RESPONSE_YES)
  631.         dialog.set_markup(msg)
  632.         res = dialog.run()
  633.         dialog.destroy()
  634.         if res == gtk.RESPONSE_YES:
  635.             return True
  636.         return False
  637.     
  638.     def confirmRestart(self):
  639.         self.dialog_restart.set_transient_for(self.window_main)
  640.         self.dialog_restart.realize()
  641.         self.dialog_restart.window.set_functions(gtk.gdk.FUNC_MOVE)
  642.         res = self.dialog_restart.run()
  643.         self.dialog_restart.hide()
  644.         if res == gtk.RESPONSE_YES:
  645.             return True
  646.         return False
  647.  
  648.     def processEvents(self):
  649.         while gtk.events_pending():
  650.             gtk.main_iteration()
  651.  
  652.     def on_window_main_delete_event(self, widget, event):
  653.         self.dialog_cancel.set_transient_for(self.window_main)
  654.         self.dialog_cancel.realize()
  655.         self.dialog_cancel.window.set_functions(gtk.gdk.FUNC_MOVE)
  656.         res = self.dialog_cancel.run()
  657.         self.dialog_cancel.hide()
  658.         if res == gtk.RESPONSE_CANCEL:
  659.             sys.exit(1)
  660.         return True
  661.  
  662. if __name__ == "__main__":
  663.   
  664.   view = DistUpgradeViewGtk()
  665.   fp = GtkFetchProgressAdapter(view)
  666.   ip = GtkInstallProgressAdapter(view)
  667.  
  668.   cache = apt.Cache()
  669.   for pkg in sys.argv[1:]:
  670.     if cache[pkg].isInstalled:
  671.       cache[pkg].markDelete()
  672.     else:
  673.       cache[pkg].markInstall()
  674.   cache.commit(fp,ip)
  675.   gtk.main()
  676.   sys.exit(0)
  677.   
  678.   #sys.exit(0)
  679.   ip.conffile("TODO","TODO~")
  680.   view.getTerminal().call(["dpkg","--configure","-a"])
  681.   #view.getTerminal().call(["ls","-R","/usr"])
  682.   view.error("short","long",
  683.              "asfds afsdj af asdf asdf asf dsa fadsf asdf as fasf sextended\n"
  684.              "asfds afsdj af asdf asdf asf dsa fadsf asdf as fasf sextended\n"
  685.              "asfds afsdj af asdf asdf asf dsa fadsf asdf as fasf sextended\n"
  686.              "asfds afsdj af asdf asdf asf dsa fadsf asdf as fasf sextended\n"
  687.              "asfds afsdj af asdf asdf asf dsa fadsf asdf as fasf sextended\n"
  688.              "asfds afsdj af asdf asdf asf dsa fadsf asdf as fasf sextended\n"
  689.              "asfds afsdj af asdf asdf asf dsa fadsf asdf as fasf sextended\n"
  690.              )
  691.   view.confirmChanges("xx",[], 100)
  692.   
  693.